home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / util / misc / UserTool1_0.lha / UserTool / Source / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-21  |  6.8 KB  |  258 lines
  1. /*
  2.  * UserTool - A Tool for managing users in a MuFS environment.
  3.  *
  4.  * $VER: parse.c 37.1 (10.1.94)
  5.  */
  6.  
  7. #include <exec/memory.h>
  8.  
  9. #include <clib/exec_protos.h>
  10. #include <clib/dos_protos.h>
  11. #include <clib/alib_protos.h>
  12. #include <clib/reqtools_protos.h>
  13.  
  14. #include <stdio.h>
  15. #include <string.h>
  16.  
  17. #include "parse.h"
  18. #include "funcs.h"
  19.  
  20. extern LONG Tags[], Startup, PasswdFileDirty, GroupFileDirty;
  21. extern UBYTE PasswdName[], GroupName[];
  22. extern struct List *Users, *Groups;
  23.  
  24. struct Node *AllocAndReturnNext( FILE *PassFile )
  25. {
  26.     UserStruct *New;
  27.     LONG rv;
  28.     UBYTE Null[256];
  29.     
  30.     if( New = AllocVec( sizeof( UserStruct ), MEMF_CLEAR )) {
  31.         if( !feof( PassFile )) {
  32.             rv = fscanf( PassFile, "%[^|]|%[^|]|%ld|%ld|%[^|]|%[^|]|%[^\n]\n",
  33.                         New->us_UserName, New->us_Password,
  34.                         &( New->us_UserID ), &( New->us_GroupID ),
  35.                         New->us_RealName, New->us_HomeDir, New->us_Port );
  36.             New->us_Node.ln_Name = New->us_UserName;
  37.             NewList( &New->us_Groups );
  38.             if( !strcmp( New->us_Password, "" ) && Startup ) {
  39.                 Tags[7] = ( LONG )"Password Warning";
  40.                 rtEZRequest( "Warning. User %s has an empty password.", "_Ok",
  41.                             0L, ( struct TagItem * )Tags, New->us_UserName );
  42.             }
  43.             
  44.             if( rv == 7 )
  45.                 return ( struct Node * )New;
  46.             else {
  47.                 fscanf( PassFile, "%[^\n]\n", Null );
  48.                 Tags[7] = ( LONG )"Password File Information";
  49.                 rtEZRequest( "Error reading password entry.", "_Ok", 0L,
  50.                             ( struct TagItem * )Tags);
  51.             }
  52.         }
  53.         FreeVec( New );
  54.     }
  55.  
  56.     return 0L;
  57. }            
  58.  
  59. struct List *ParsePasswdFile( VOID )
  60. {
  61.     static struct List UserList;
  62.     FILE *PassFile;
  63.     struct Node *User;
  64.     
  65.     NewList( &UserList );
  66.  
  67.     if( PassFile = fopen( PasswdName, "r" )) {
  68.         while( !feof( PassFile )) {
  69.             if( User = AllocAndReturnNext( PassFile ))
  70.                 AddTail( &UserList, User );
  71.         }
  72.         fclose( PassFile );
  73.     } else {
  74.         Tags[7] = ( LONG )"Password File Information";
  75.         rtEZRequest( "Error opening password file: %s\n", "_Ok", 0L,
  76.                     ( struct TagItem * )Tags, PasswdName );
  77.     }
  78.  
  79.     PasswdFileDirty = 0;
  80.     
  81.     return &UserList;
  82. }    
  83.  
  84. /* If User is non-null, then that user's password will be copied as null,
  85.    useful for changing her password since MuFS doesn't support changing of
  86.    passwords without the old password (even if you're root...). */
  87.  
  88. VOID WritePasswdFile( UserStruct *User )
  89. {
  90.     UBYTE PasswdBack[1024];
  91.     FILE *PassFile;
  92.     UserStruct *SaveUser;
  93.     
  94.     strcpy( PasswdBack, PasswdName );
  95.     strcat( PasswdBack, ".bak" );
  96.  
  97.     DeleteFile( PasswdBack );
  98.     if( !Rename( PasswdName, PasswdBack )) {
  99.         Tags[7] = ( LONG )"Password File Information";
  100.         rtEZRequest( "Cannot delete backup password file.", "_Ok", 0L,
  101.                     ( struct TagItem * )Tags );
  102.         return;
  103.     }
  104.     
  105.     if( PassFile = fopen( PasswdName, "w" )) {
  106.         for( SaveUser = ( UserStruct * )Users->lh_Head;
  107.             SaveUser->us_Node.ln_Succ;
  108.             SaveUser = ( UserStruct * )SaveUser->us_Node.ln_Succ )
  109.             fprintf( PassFile, "%s|%s|%ld|%ld|%s|%s|%s\n",
  110.                     SaveUser->us_UserName,
  111.                     SaveUser == User ? "" :    ( char * )SaveUser->us_Password,
  112.                     SaveUser->us_UserID, SaveUser->us_GroupID,
  113.                     SaveUser->us_RealName, SaveUser->us_HomeDir,
  114.                     SaveUser->us_Port );
  115.         fclose( PassFile );
  116.     } else {
  117.         Rename( PasswdBack, PasswdName );
  118.         Tags[7] = ( LONG )"Password File Information";
  119.         rtEZRequest( "Error opening password file: %s\n", "_Ok", 0L,
  120.                     ( struct TagItem * )Tags, PasswdName );
  121.     }
  122.  
  123.     PasswdFileDirty = 0;
  124.  
  125. }
  126.  
  127. struct Node *AllocAndReturnNextG( FILE *GroupFile )
  128. {
  129.     GroupStruct *New;
  130.     UBYTE Line[256];
  131.     LONG rv;
  132.     int c;
  133.     
  134.     if(( c = fgetc( GroupFile )) == '\n' )
  135.         return 0L;
  136.     else
  137.         ungetc( c, GroupFile );
  138.     
  139.     if( New = AllocVec( sizeof( GroupStruct ), MEMF_CLEAR )) {
  140.         if( !feof( GroupFile )) {
  141.             if( fgets( Line, 256, GroupFile )) {
  142.                 rv = sscanf( Line, "%[^|]|%ld|%ld|%[^\n]\n", New->gs_GroupID,
  143.                             &( New->gs_GID ), &( New->gs_MgrID ),
  144.                             New->gs_Name );
  145.                 New->gs_Node.ln_Name = New->gs_GroupID;
  146.                 
  147.                 if( rv == 4 )
  148.                     return ( struct Node * )New;
  149.                 else {
  150.                     Tags[7] = ( LONG )"Group File Information";
  151.                     rtEZRequest( "Error parsing group entry.", "_Ok", 0L,
  152.                                 ( struct TagItem * )Tags );
  153.                 }
  154.             } else {
  155.                 Tags[7] = ( LONG )"Group File Information";
  156.                 rtEZRequest( "Error reading group entry.", "_Ok", 0L,
  157.                             ( struct TagItem * )Tags );
  158.             }
  159.         }
  160.         FreeVec( New );
  161.     }
  162.  
  163.     return 0L;
  164. }            
  165.  
  166. struct List *ParseGroupFile( VOID )
  167. {
  168.     static struct List GroupList;
  169.     struct Node *Group;
  170.     FILE *GroupFile;
  171.     LONG GID, UID;
  172.     UBYTE GroupLine[1024];
  173.     
  174.     NewList( &GroupList );
  175.  
  176.     if( GroupFile = fopen( GroupName, "r" )) {
  177.         while( Group = AllocAndReturnNextG( GroupFile ))
  178.             AddTail( &GroupList, Group );
  179.         while( !feof( GroupFile )) {
  180.             if( fgets( GroupLine, 1024, GroupFile )) {
  181.                 LONG GLPos = 0;
  182.                 if(( UID = GetNextNumber( GroupLine, &GLPos )) >= 0 ) {
  183.                         do {    
  184.                             if(( GID = GetNextNumber( GroupLine, &GLPos ))> 0 )
  185.                                 if( AddGroupToUser( UID, GID ))
  186.                                     break;
  187.                         } while( GID >= 0 );
  188.                 } else {
  189.                     Tags[7] = ( LONG )"Group File Information";
  190.                     rtEZRequest( "Error parsing GID and first UID from group"
  191.                                 " file.", "_Ok", 0L,
  192.                                 ( struct TagItem * )Tags );
  193.                 }
  194.             } else if( !feof( GroupFile )) {
  195.                 Tags[7] = ( LONG )"Group File Information";
  196.                 rtEZRequest( "Error reading group entry from group file.",
  197.                             "_Ok", 0L, ( struct TagItem * )Tags );
  198.             }
  199.         }
  200.         fclose( GroupFile );
  201.     } else {
  202.         Tags[7] = ( LONG )"Group File Information";
  203.         rtEZRequest( "Error opening Group file: %s\n", "_Ok", 0L,
  204.                     ( struct TagItem * )Tags, GroupName );
  205.     }
  206.  
  207.     GroupFileDirty = 0;
  208.  
  209.     return &GroupList;
  210. }
  211.  
  212. VOID WriteGroupFile( VOID )
  213. {
  214.     UBYTE GroupBack[1024];
  215.     FILE *GroupFile;
  216.     GroupStruct *SaveGroup;
  217.     UserStruct *SaveUser;
  218.     struct Node *SaveNode;
  219.     
  220.     strcpy( GroupBack, GroupName );
  221.     strcat( GroupBack, ".bak" );
  222.  
  223.     DeleteFile( GroupBack );
  224.     if( !Rename( GroupName, GroupBack )) {
  225.         Tags[7] = ( LONG )"Group File Information";
  226.         rtEZRequest( "Cannot delete backup group file.", "_Ok", 0L,
  227.                     ( struct TagItem * )Tags );
  228.         return;
  229.     }
  230.     
  231.     if( GroupFile = fopen( GroupName, "w" )) {
  232.         for( SaveGroup = ( GroupStruct * )Groups->lh_Head;
  233.             SaveGroup->gs_Node.ln_Succ;
  234.             SaveGroup = ( GroupStruct * )SaveGroup->gs_Node.ln_Succ )
  235.             fprintf( GroupFile, "%s|%ld|%ld|%s\n", SaveGroup->gs_GroupID,
  236.                     SaveGroup->gs_GID, SaveGroup->gs_MgrID,
  237.                     SaveGroup->gs_Name );
  238.         fprintf( GroupFile, "\n" );
  239.         for( SaveUser = ( UserStruct * )Users->lh_Head;
  240.             SaveUser->us_Node.ln_Succ;
  241.             SaveUser = ( UserStruct * )SaveUser->us_Node.ln_Succ ) {    
  242.             if( SaveUser->us_Groups.lh_Head->ln_Succ ) {
  243.                 fprintf( GroupFile, "%ld:", SaveUser->us_UserID );
  244.                 for( SaveNode = SaveUser->us_Groups.lh_Head; SaveNode->ln_Succ;
  245.                     SaveNode = SaveNode->ln_Succ )
  246.                     fprintf( GroupFile, "%ld%s", SaveNode->ln_Pri,
  247.                             SaveNode->ln_Succ->ln_Succ ? "," : "\n" );
  248.             }
  249.         }
  250.         fclose( GroupFile );
  251.     } else {
  252.         Rename( GroupBack, GroupName );
  253.         Tags[7] = ( LONG )"Group File Information";
  254.         rtEZRequest( "Error opening group file: %s\n", "_Ok", 0L,
  255.                     ( struct TagItem * )Tags, GroupName );
  256.     }
  257. }
  258.